Methods and systems for creation and use of raw-data datastore

ABSTRACT

A raw-data datastore during data analysis and feature recognition abstracts away and/or reduces dependency upon typically required components of datastore training. The datastore functions to store the original data values of a data set selection, which can represent a known feature. In some embodiments, the original data set is retained as the raw data value set referenced by the raw-data datastore. The use of this raw-data datastore eliminates the need for continued manual retraining of the original data values and patterns, which can be associated with a particular known feature, each time the pluralities of evaluation algorithms and/or the target data area are altered, changed, modified, or reconfigured.

PRIORITY CLAIM

This application claims the benefit of U.S. Provisional Application Ser. No. 61/037,998 filed Mar. 19, 2008, contents of which are incorporated herein.

FIELD OF THE INVENTION

The present invention, in various embodiments, relates generally to the fields of data analysis and feature recognition and more particularly to refinement of said systems for the purpose of improving training methods and algorithm design.

BACKGROUND OF THE INVENTION

Data analysis and feature recognition systems, such as described by Brinson, et al., in U.S. patent application 2007/0244844, which is incorporated by reference in its entirety herein, or any user-specified, preset, or automatically determined application or engine engaged for use in the same or a similar manner, afford users the capability and capacity to perform data analysis of, feature recognition within, and/or data transformation of the representative data of a given data set selection(s), regardless of the medium or data type, modality, submodality, etc., in an effort to extract useful or meaningful information from what otherwise may be hollow or enigmatic data, to provide visualization alternatives, and/or to aid in the formulation of hypotheses or conclusions relating to or derived from the original data. The processes used by such a system vary by application use, genre pertinence, user specifications, system requirements, and the like but generally invoke the system to recognize the unique data values and patterns characteristic of a particular target feature(s) of interest (hereafter “known feature(s)”) within a given data set and subsequently distinguish these associated data values and patterns upon evaluation of succeeding data sets containing the previously identified known feature(s).

For example, a user desires to identify areas of deforestation in imagery of a South American rain forest. Using evaluation algorithms and a sampling area of data (i.e., any collection of data elements surrounding or associated with one or pluralities of centralized data elements) (hereafter “target data area”), a data analysis and feature recognition system is employed to analyze a selection of data, which is known by the user to contain the known feature of interest “Deforestation,” from the original data set. In an alternate embodiment, pluralities of evaluation algorithms and the target data area (TDA) are used to evaluate the original data set in its entirety. Ultimately, the algorithmically ascertained data values and patterns, which are crucial to the definitive recognition of the inherent characteristics of “Deforestation,” are then stored, or trained, into a previously established data storage structure, such as an algorithm datastore or any user-specified, preset, or automatically determined storage device (e.g., a data array, database, data output overlay, value cache, datastore) capable of at least temporarily storing data, as the newly identified known feature “Deforestation.”

In the aforementioned example, “Deforestation” is uniquely identified from other features in the data set selection by the distinct combinations of calculated algorithm values and patterns obtained from analysis of the original data set selection using the intentionally selected and ordered pluralities of evaluation algorithms and/or the specifically chosen TDA. Accordingly, future attempts to positively identify “Deforestation” within subsequent imagery of the South American rain forest using this previously trained algorithm datastore require the use of the same pluralities of evaluation algorithms and the same TDA as were used to train the algorithm datastore in the first place. This ensures proper comparison and correlation of the uniquely identified data values and patterns, which are associated with “Deforestation” and stored in the algorithm datastore, with the newly procured and analyzed data of subsequent imagery.

Such a data analysis and feature recognition system as described previously is often plagued by system, data, ground truth, and/or algorithm inadequacies that can make successful user interaction with the system problematic. The inherent deficiencies of such a system are examined forthwith.

Assume a user has trained a data analysis and feature recognition system to recognize the data values and patterns of the known feature “Deforestation” using specific pluralities of evaluation algorithms and a given TDA. Afterwards, the user discovers that slightly or even heavily modified pluralities of evaluation algorithms, which can include several additional algorithms not originally included or previously available, are actually better suited for delimiting “Deforestation” in subsequent imagery. If the user processes the subsequent imagery using these modified, yet more pertinent, pluralities of evaluation algorithms with the ultimate intent being the identification of “Deforestation” within the imagery, all historical training becomes inapplicable thus resulting in recognition of few or potentially no data values and patterns associated with “Deforestation.” This is because a change in the algorithm set results in the calculation of different data values and patterns so that even when “Deforestation” exists in subsequent imagery, the system is unable to recognize or reveal it. Once more, since all historical training of “Deforestation” is irrelevant when the pluralities of evaluation algorithms are altered, the situation demands that the known feature “Deforestation” either be retrained, which can be time or cost prohibitive, using the original data set and the new pluralities of evaluation algorithms or the subsequent imagery must continue to be evaluated using the original pluralities of evaluation algorithms, which can be inaccurate or flawed.

Similarly, in an alternate instance, the user realizes that the TDA used to evaluate a given data set is ineffective or deficient and chooses to alter the TDA in order to achieve improved analysis results. As described previously, all historical training of the known feature “Deforestation” is lost if the TDA used to evaluate subsequent imagery is different from the TDA used in the assessment of the original data set. This is because a change in the TDA results in the calculation of algorithm values on different data and patterns thereby preventing correlation of the previously trained data with the newly trained data.

A second difficulty, which tends to be prevalent in many data analysis and feature recognition systems on the market today, is a situation most aptly described as “algorithm confusion.” Simply, algorithm confusion is the inability of the evaluation algorithms, which operate on a given TDA, to correctly distinguish between different sets of data values and patterns that have been previously trained and stored in a datastore as a different known feature(s). This feature misidentification is compounded when the algorithm datastore is queried to identify the previously trained, unique known feature in a subsequent data set. In such a situation, the evaluation algorithms are unable to definitively distinguish between different known features, which exist within the same data set but possess distinct data values and patterns.

Thirdly, a typical data analysis and feature recognition system may be unable to correctly distinguish between individually trained known features as a result of “data confusion,” which describes a scenario wherein identical data values and patterns within a given data set are trained as more than one different known feature. Data confusion can result from two primary causes: (1) during training, the user makes a mistake, such as overlapping a portion(s) of the training selection areas for the affected known features; or (2) the resultant data values of the given TDA are identical to those at a different location(s) due to a lack of sensor resolution or sensitivity in the data recording mechanism. This is especially problematic because, in the case of data confusion, erroneous information is introduced at the training stage of data analysis, and this misinformation can persist as long as the training is being used. Once the system is in use, there is no functionality available to allow the user or the system to go back and review the training selections made during earlier stages of algorithm datastore construction.

Complicating matters further is that use of the standard methods of algorithm datastore training for the purpose of feature identification does not commonly enlighten the user as to whether conflicting or erroneous datastore training is due to ambiguous source data (i.e., data confusion), faulty data selections during training (i.e., data confusion), inadequacy with regard to the TDA selected for use to solve the problem at hand (i.e., data confusion), scantiness of the evaluation algorithms employed to distinguish between the data values and patterns representing the different known features (i.e., algorithm confusion), or another unidentified problem.

SUMMARY OF THE INVENTION

The methods and systems for the creation and use of a raw-data datastore during data analysis and feature recognition are disclosed herein. In the preferred embodiment, the present invention abstracts away and/or reduces dependency upon typically required components of datastore training; these include, inter alia, the original data source(s), data set(s), or media stream and/or processing selections or regions of interest. Moreover, an algorithm datastore does not need to be manually retrained each time the series of evaluation algorithms and/or the TDA are altered, changed, modified, or reconfigured. This is accomplished through the use of a datastore that functions to store the original data values of a data set selection, which can represent a known feature. In some embodiments, the original data set is retained as the raw data value set referenced by the raw-data datastore.

The methods and systems as disclosed herein programmatically obtain the raw data values from an original data set(s) or selection(s) therein and store these data values in a raw-data, preferably data-source independent, datastore to satisfy the future needs of the data analysis and feature recognition system. The raw data values are obtained and trained into the raw-data datastore, or any equivalent software or hardware application or engine capable of at least temporarily storing data, using similar training methods such as described by Brinson, et al., in U.S. patent application 2007/0244844 or as accomplished by any methodology, application, or engine intended for use in the same or a similar manner. The use of this raw-data datastore eliminates the need for continued manual retraining of the original data values and patterns, which can be associated with a particular known feature, each time the pluralities of evaluation algorithms and/or the TDA are altered, changed, modified, or reconfigured.

The methods and systems as disclosed herein are capable of efficiently and effectively adapting to changes in the evaluation algorithm selection and/or TDA size, shape, and/or type when an observed, proven, or a prior need for further or better evaluation of the data is perceived by a user of the system or some other acceptable means or method. In one embodiment, the methods and systems of the present invention allow for an algorithm “plug-and-play” capability wherein the evaluation algorithms can be interchanged, added, subtracted, removed, masked, divided, etc., during data set evaluation and raw-data datastore training as frequently as the user of the system or some other acceptable authority deems necessary. This is accomplished by training the raw-data datastore with the programmatically derived raw data values obtained from the original data set. In some embodiments, the methods and systems of the present invention are improved using an automatic process to deductively determine and/or predict the best available pluralities of evaluation algorithms obtainable for evaluation of the data set(s) of interest.

In an alternate embodiment, the methods and systems are configured so as to use a TDA that is detailed, thorough, and/or encompassing enough to allow subset or fractionalized TDAs to be derived from or manipulated within it. Instead of relying on the original TDA used to evaluate the original data set(s) and populate the raw-data datastore, this functionality permits on-the-fly changes to the TDA used to analyze subsequent data sets and/or populate associated algorithm datastores. In yet another embodiment, the data analysis and feature recognition system is automatically retrained using any applicable and available TDA that is compatible with the original data set(s) or selection(s) therein.

In one embodiment, the methods and systems as disclosed herein incorporate a raw-data datastore capable of storing the raw data values, which are analytically obtained from the original data set(s) or selection(s) therein, in a manner so as to allow data confusion to be easily and systematically pinpointed. This raw-data datastore makes the presence of data confusion obvious as soon as raw-data datastore training is complete. In one embodiment, the system displays all locations in the original data set that are involved in any data confusion in accordance with the current training; this is accomplished in an attempt to ensure that the user obtains the best possible starting training base containing a minimum amount of data confusion. In an alternate embodiment, the system is able to isolate, within the original data set(s) or selection(s) therein, the exact data element(s) originally trained as particular entries in the raw-data datastore.

In one embodiment, the methods and systems as disclosed herein incorporate a raw-data datastore capable of storing the raw data values, which are analytically obtained from the original data set(s) or selection(s) therein, in a manner so as to allow algorithm confusion to be easily and systematically pinpointed. When the raw-data datastore is analyzed concurrently with an associated algorithm datastore, which has been previously generated from the given raw-data datastore using pluralities of evaluation algorithms and a single TDA or by any other application or engine intended for use in the same or a similar manner, it is possible for the system to identify the precise sets of raw data values within the trained known feature that are undistinguishable despite having been trained as different known features by the given pluralities of evaluation algorithms and/or TDA, which have been specified for use to solve the data analysis problem at hand.

Since it may be desirable to use the original raw-data datastore to add new training in the future, as well as to generate multiple algorithm datastores for use in other data analysis and feature recognition applications, for example, the abilities to accurately and programmatically analyze and correct the raw-data datastore training, at the point of training as in the case of data confusion or as soon as an analysis process has pinpointed the problem data set and pattern for particular pluralities of algorithms and/or TDA as in the case of algorithm confusion, are of paramount importance to users developing such systems because the quality of the final feature identification datastore is largely determined by the quality of the training base upon which it depends.

BRIEF DESCRIPTION OF THE DRAWINGS

Preferred and alternative examples of the present invention are described in detail below with reference to the following drawings:

FIG. 1 shows one embodiment of an example data analysis and feature recognition system employed for creation and use of a raw-data datastore;

FIG. 2 shows an example method for creating and training a raw-data datastore for use with a data analysis and feature recognition system;

FIG. 3 shows an example method for creating a raw-data datastore;

FIG. 4 shows an example method for creating a known feature;

FIG. 5 shows an example method for modifying a raw-data datastore by training or untraining;

FIG. 6 shows an example method for generating a data value cache;

FIG. 7 shows an example method for training a known feature;

FIG. 8 shows an example method for developing a training entry array from positive and negative training value sets;

FIG. 9 shows an example method for performing adjusted training by removing negative training value sets from the collection;

FIG. 10 shows an example method for untraining a known feature;

FIG. 11 shows an example 20-data element by 20-data element data array of a two-dimensional, grey-scale image selection of two features;

FIG. 12 shows the seven-data element by seven-data element TDA;

FIG. 13 shows the eight radial, three data elements per radial, TDA;

FIG. 14 shows the adjacent-data element TDA;

FIG. 15 shows the adjacent cardinal-data element TDA;

FIG. 16 shows the eight-data element by eight-data element TDA;

FIG. 17 shows the series of concentric squares TDA;

FIG. 18 shows the eight radial, three-data elements per radial TDA (TDA1) with each member-data element labeled with the respective “GetValue” method (labeled “Value1” through “Value25”) that is to evaluate it;

FIGS. 19A-19G show an example data table, which is indexed by TDE location for reference purposes, representing one embodiment of the complete data value cache;

FIGS. 20A-20D show an example data table, which is indexed by TDE location for reference purposes, representing one embodiment of the complete raw-data datastore, which is populated with the data sets associated with KF1 and KF2;

FIG. 21 shows an example data table representing the results of the algorithmic evaluation of the raw-data datastore entry corresponding to TDE location reference (4, 4) with ALG1 using TDA1;

FIG. 22 shows an example data table representing the results of the algorithmic evaluation of the raw-data datastore entry corresponding to TDE location reference (4, 4) with ALG2 using TDA1;

FIG. 23 shows an example data table representing one embodiment of AlgDS1 that contains the results of algorithmic evaluation of the raw-data datastore entries with ALG1 and ALG2 using TDA1;

FIG. 24 shows an example data table representing one embodiment of AlgDS2 that contains the results of algorithmic evaluation of the raw-data datastore entries with ALG3 and ALG4 using TDA2;

FIGS. 25A-25B show an example data table representing one embodiment of AlgDS3 that contains the results of algorithmic evaluation of the raw-data datastore entries with ALG5, ALG6, and ALG3 using TDA3;

FIG. 26A shows an example data array, which represents an adjacent-data element TDA with an associated TDE (2, 2), to be used in conjunction with FIG. 26B for illustration of data confusion;

FIG. 26B shows an example data array, which represents an adjacent-data element TDA with an associated TDE (22, 22), to be used in conjunction with FIG. 26A for illustration of data confusion;

FIG. 27A shows an example data array, which represents an adjacent-data element TDA with an associated TDE (5, 5), to be used in conjunction with FIG. 27B for illustration of algorithm confusion;

FIG. 27B shows an example data array, which represents an adjacent-data element TDA with an associated TDE (25, 25), to be used in conjunction with FIG. 27A for illustration of algorithm confusion;

FIG. 28 shows an example data table containing a truncated portion of an example raw-data datastore with an instance of data confusion highlighted;

FIG. 29 shows an example data table containing a truncated portion of an example raw-data datastore with an instance of algorithm confusion highlighted;

FIG. 30 shows an alternate embodiment of an example raw-data datastore wherein a three-dimensional data set is trained; and

FIG. 31 shows an alternate embodiment of an example raw-data datastore wherein both selections and the original data sets' data values are retained.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT

The methods and systems for creation and use of a raw-data, source-independent datastore as described herein preferably eliminate the aforementioned delinquencies of a typical data analysis and feature recognition system. This raw-data datastore functions to capture the data values and patterns inherent to the original source data set(s) or selection(s) therein using one or pluralities of data capture operations and a broad-scope TDA. Such germane data analysis tactics ensure the preservation of the raw data set, or selection therein, and the ability of the user or system to experiment with varying combinations of TDAs and evaluation algorithms in a concerted effort to determine the best possible solution for evaluation of the subject data and identification of desired features in subsequent, related data sets. Most beneficially, the raw-data datastore provides users the ability to retrain a new algorithm datastore exactly as an original raw-data datastore is trained while using new and/or altered, changed, modified, or reconfigured evaluation algorithms, algorithm settings, and/or a TDA, assuming the new TDA is a subset or portion of the original. Moreover, usage of a raw-data datastore during data analysis ensures the ability to pinpoint occurrences of data and/or algorithm confusion, which often plague training events causing ambiguous feature identification results; in some embodiments, the raw-data datastore provides a reference-guide-like functionality for the user desiring to isolate the exact data element location(s) where data and/or algorithm confusion exist within the data set or selection therein so as to permit immediate correction of the problem; and use of the raw-data datastore permits partial or in some cases complete fabrication of the original data set or selection therein from the previously obtained and stored raw data values if, by chance, the original data set is lost, damaged, corrupted, unpreserved, etc.

A data analysis and feature recognition system (such as disclosed by Brinson, et al., in U.S. patent application 2007/0244844 or as accomplished using any application or engine intended for use in the same or a similar manner) is configured to accept an original source data set containing one or pluralities of known and pre-identified features (e.g., a known pattern, shape, object, or entity). The system is generally configured such that the user can “train” the system by recording data values (or location references) representing the known feature(s). This training is accomplished through execution of algorithmic methods that capture and preserve the data values (or location references) defining the feature(s). These sets of data values (or location references) are then stored in an organizational storage structure (e.g., a raw-data datastore such as described herein; a synaptic web such as described by Brinson, et. al.; a data store; a data array; a data table; any user-specified, preset, automatically determined, and/or industry- or system-acceptable storage structure intended for use in the same or a similar purpose).

Once the raw-data datastore is trained for a known feature(s), the raw data values (or location references), which are innate to the original source data set or selection therein, can be subsequently and repeatedly analyzed via multitudinous combinations of the same or different evaluation algorithms and compatible TDAs. Fundamental to the usefulness of a raw-data datastore is the premise that complex algorithmic calculations are not required in the attainment of the raw data values (or location references) of the original data set or selection. This is because once the raw data values and patterns (or location references) are systematically obtained and trained into the raw-data datastore, all future data analysis and feature recognition training, processing, and/or associated modifications or additions, as well as auto-retraining and/or auto-generation of new algorithm datastores, rely on these raw data values (or location references) instead of the original data set in and of itself. Essentially, the data as stored in the raw-data datastore becomes the source data for subsequent algorithm datastore renderings thereby affording the user and the system significant cost savings, in the form of processing time and temporary storage needs, as efforts are made to achieve the most successful processing results possible. Ultimately, storage of the raw data set or the selected portion(s) therein may not be required for future training and/or analysis needs of subsequent algorithm datastores and may in fact become obsolete. In pluralities of alternate embodiments, the raw data set or selections therein are retrained by the system resulting in a system capable of offering enhanced assistance with data and/or algorithm confusion resolution, and a greater ability to manually or automatically retrain the system using different pluralities of evaluation algorithms and/or different TDAs. In alternate embodiments, further and additional algorithm datastores with values derived from the analysis of the raw-data datastore are also generated.

The methods and systems for creation and use of a raw-data, data-source-independent datastore as described herein are intended to function as measures to reduce the burden of retraining that is required in typical data analysis and feature recognition systems when either the evaluation algorithm(s) or the TDA are altered, changed, modified, or reconfigured between processing runs and also to aid in the resolution of occurrences of data and/or algorithm confusion that can persist from flawed or ambiguous data, TDA and/or algorithm(s) selections, user error, etc. In some embodiments, the methods and systems as described herein improve upon the data analysis and feature recognition methodologies and engine as described by Brinson, et al., while in an alternate embodiment, any processing application or engine intended for use in the same or a similar manner can be referenced.

Although several of the data analysis and feature recognition system embodiments and examples as discussed herein are described with reference to specific data types, modalities, submodalities, etc., such as imagery data sets, the present invention is not limited in scope or breadth to analysis of these data types. The methods and systems as described herein can be used to analyze and/or recognize discrete features in any data set or other collection of information that can be represented in a quantifiable datastore.

As used herein, the term “algorithm datastore” refers to any software or hardware element capable of at least temporarily storing data. In several embodiments, the datastore(s) referred to herein contains pluralities of known features represented by pluralities of characteristic data values and patterns (or location references) generated by one or more evaluation algorithms associated with a particular TDA.

As used herein, the term “raw-data datastore” carries a similar meaning as “algorithm datastore” but more specifically functions to store the raw data values (or location references) that are systematically retrieved from an original data set or selection therein using pluralities of information-reporting operations (e.g., a series of “GetValue” methods that report raw data element values or location references rather than perform some mathematical function on the original data values) and a particular TDA. The raw-data datastore can contain pluralities of known features characterized by pluralities of raw data values and patterns (or location references).

As used herein, the term “target data element” (TDE) refers to a discrete portion of a larger data set in a given data stream or medium that is being evaluated for characteristics using evaluation algorithms and a given TDA. A TDE can be any size appropriate for a particular data type, modality, submodality, etc. For example, in a set of graphical data, a TDE can consist of a single pixel, a localized grouping of pixels, or any other discrete grouping of pixels. In several embodiments and regardless of size, a TDE is a “point” that is evaluated in a single discrete step before processing moves to the next valid TDE in the data set or selection therein.

As used herein, the term “target data area” (TDA) refers to an ordered collection of data elements immediately surrounding a TDE. The size and shape of the TDA vary depending upon the type of data or medium that is evaluated, user specifications, and/or industry- or system-acceptable standards and can define the member-data elements available for inclusion during evaluation or recording of a given TDE.

As used herein, the term “known feature” (KF) refers to an element of data representing an entity, item, object, pattern, or other discretely definable piece of information known to be present in a particular data set during training. At the time of data processing, the system searches a new data set for one or more of the previously defined known features.

As used herein, the term “training (event)” refers to the process of associating pluralities of data values (or location references) from a given data stream to a particular feature by establishing and/or updating the data values (or location references) and/or evaluation pathways as stored in a user-specified, preset, automatically determined, and/or industry- or system-acceptable organizational storage structure, such as a datastore, value cache, synaptic web, data array, data table, etc.

As used herein, the term “positive training value set(s)” refers to the sets of data values (or location references) that are located inside the area of data trained as the user-defined known feature.

As used herein, the term “negative training value set(s)” refers to the sets of data values (or location references) that are located outside the area of data trained as the user-defined known feature.

As used herein, the term “relative adjusted training” refers to a process used during a training event whereby each of the data values (or location references) found in the negative training value set nullifies one matching set of data values (or location references) found inside the positive training value set. The remaining positive training value sets can then be used to generate training entry value sets for the known feature.

As used herein, the term “absolute adjusted training” refers to a process used in a training event whereby each set of data values (or location references) found in a negative training value set nullifies all matching sets of data values (or location references) found in the positive training value set. The remaining positive training value sets can then be used to generate training entry value sets for the known feature.

As used herein, the term “(data) modality” retains its traditional meaning and refers to one of the various forms or formats of digital data that can be processed. For example, image data represents one modality, while sound data represents another. In addition to describing data types that conform to one or more human sensory modalities, the term is also intended to encompass data types and formats that might have little or no relation to the human senses. For example, financial data, demographic data, and literary data also represent modalities within the definition of the term as used herein.

As used herein, the term “(data) submodality” refers to a sub-classification of a data modality. In some embodiments, a submodality refers to one of the applications or sources for the data that can affect how the data is processed. For example, X-ray and satellite photography are submodalities of the imaging modality. Moreover, systems that are manufactured by different vendors (e.g., GENERAL ELECTRIC, SIEMENS) but are used for producing X-ray images can vary enough in their data formats to require separation into different submodalities.

FIG. 1 shows an example system 100 for creation and use of a raw-data datastore by a data analysis and feature recognition system, such as disclosed by Brinson, et al., in U.S. patent application 2007/0244844, or as accomplished using any application or engine intended for use in the same or a similar manner. In one embodiment, the system 100 includes a single computer 101. In an alternate embodiment, the system 100 includes a computer 101 in communication with pluralities of other computers 103. In an alternate embodiment, the computer 101 is connected with pluralities of other computers 103, a server 104, a datastore 106, and/or a network 108, such as an intranet or the Internet. In yet another embodiment, a bank of servers, a wireless device, a cellular telephone, and/or another data capture/entry device(s) can be used in place of the computer 101. In one embodiment, a data storage device 106 stores a data analysis and feature recognition raw-data datastore. The data storage device 106 can be stored locally at the computer 101 or at any remote location while remaining retrievable by the computer 101. In one embodiment, an application program, which creates the raw-data datastore, is run by the server 104 or by the computer 101. Also, the computer 101 or server 104 can include an application program(s) that trains a feature(s) in a digital data stream. In one embodiment, the medium is one or pluralities of image pixels.

FIG. 2 shows an example method formed in accordance with an embodiment of the present invention. The method initializes at block 200, and at block 202, a raw-data datastore is created; this is described in more detail with reference to FIGS. 3-4. At block 204, a known feature is trained; this is described in more detail with reference to FIGS. 5-10.

FIG. 3 shows an example method 202 for creating a raw-data datastore. The method 202 initializes at block 208 and at block 210, pluralities of raw-data datastore properties are assigned. In one embodiment, the datastore properties include, inter alia, declaration of the data set modality and submodality. At block 212, a known feature(s) is created; this is described in more detail with reference to FIG. 4. At block 214, a TDA is assigned. The TDA used for evaluation of the raw data values and patterns (or location references) of the original data set can exist in any applicable geometric configuration, shape, or pattern, can contain any number of applicable dimensions, and can consist of any number of raw data elements. One example TDA is starburst-like in shape wherein the data elements are arranged in a pattern of eight radials with three data elements per radial. Note that the more encompassing the TDA used during raw-data datastore population is, the easier it is to alter, change, manipulate, or reconfigure during subsequent data analysis and feature recognition exercises, such as the creation of ensuing algorithm datastores.

At block 216 of FIG. 3, a selection is made between using the “GetValue” method versus the “GetLocation” method for raw data capture. In one embodiment, a simplistic, information reporting operation, such as the “GetValue” method, which with regard to imagery can return the grey-scale value of the pixel being evaluated or the “GetLocation” method, which in one instance returns the location reference coordinates (e.g., X, Y, Z) of the pixel being evaluated, is used to populate the raw-data datastore with the data values and patterns (or location references) inherent to the original data set. The “GetValue” and “GetLocation” methods can be modified and used to capture the data values and location references, respectively, of any applicable medium or data set type, modality, submodality, etc., and are not limited to evaluation in the imagery embodiment alone. In an alternate embodiment, the information reporting operation can be any method called to report other data element information (e.g., data element demographic information such as data source, brightness, or elevation), characteristics, or relationships. In an alternate embodiment, the method used to populate the raw-data datastore can be any combination of methods and associated calculations, such as the “GetValue” method used in conjunction with a spatial iteration algorithm; such a combination finds applicability in specific industries and genres, such as change detection across multiple frames of data where spatial relationships among data elements are of paramount importance when attempting to recognize feature change. In an alternate embodiment, an automated process can be used to decipher the “best available” method(s) and/or algorithm(s) for use in evaluation of the original data set or selection therein. Here, the “best available” method(s) and/or algorithm(s) possess any of the following characteristics, which are important or relevant to evaluation of the subject data set or selection therein, including increased efficiency, productivity, and/or specificity; reduced cost with regard to time and/or processing requirements; etc. In an alternate embodiment, the method(s) and/or algorithm(s) used are masked, divided, etc., so as to decrease the specificity of the data values and patterns (or location references) returned. In yet another alternate embodiment, selection of a particular TDA at block 214 dictates which method(s) and/or algorithm(s) are to be used to populate the raw-data datastore with the data values (or location references) of the original data set or selection therein.

At block 218 of FIG. 3, the raw-data datastore is saved to the computer 101 or to the network 108. Blocks 212, 214, and 216 can be executed in any order.

FIG. 4 shows an example method 212 for creating a known feature. The method 212 initializes at block 220, and at block 222, a name for a known feature is entered into the system of the present invention. At block 224, a method of feature detection is assigned to the known feature. In one embodiment, the method of feature detection can be set to hit detection, cluster detection, or threshold detection; in an alternate embodiment, cluster detection and threshold detection can be selected together. At block 226, the method 212 is complete. Blocks 222 and 224 can be executed in any order.

FIG. 5 shows an example method 204 for modifying a raw-data datastore by training or untraining. The method 204 initializes at block 228, and at block 230, a data value cache is generated; this is described in more detail with reference to FIG. 6. At block 232, an area of the original data set that is known to contain the feature to be trained (i.e., region of interest) is defined and/or selected by the user. At block 234, the positive training value sets are retrieved. At block 236, a decision is made as to whether the user is performing adjusted training. If YES at block 236, at block 238 the negative training value sets are retrieved, and the method 204 proceeds to block 240. If NO at block 236, at block 240 a decision is made as to whether the user is training a known feature. If YES at block 240, at block 242 a known feature is trained; this is described in more detail with reference to FIGS. 7-9. At block 244, the number of unique data values and patterns (or location references), which are added to and/or updated in the raw-data datastore, are reported, and the method 204 is complete. If NO at block 240, at block 246 a known feature is untrained; this is described in more detail with reference to FIGS. 8 and 10. At block 248, the number of unique data values and patterns (or location references), which are removed from the raw-data datastore, are reported, and the method 204 is complete. In one embodiment, blocks 230 and 232 can be executed in any order. Also in one embodiment, block 234 and the combination of blocks 236 and 238 can be executed in any order.

FIG. 6 shows an example method 230 for generating a data value (or location reference) cache. In one embodiment, a data value (or location reference) cache, which is sized and addressed in the same or similar manner as the raw data set selection, consists of an array to store the results of the data values (or location references) capture processes. The method 230 initializes at block 250, and at block 252 the first valid TDE of the raw data set selection is retrieved. At block 254, the data values (or location references) on the TDA for the given TDE are captured. At block 256, the data values (or location references) are stored in a data value (or location reference) cache at a location corresponding to the given TDE. At block 258, a decision is made as to whether there are any more TDEs remaining in the raw data set selection that are available for capture. If YES at block 258, at block 260 the next TDE is retrieved, and the method 230 returns to block 254. If NO at block 258, at block 262 the completed data value (or location reference) cache is returned, and the method 230 is complete.

FIG. 7 shows an example method 242 for training a known feature. The method 242 initializes at block 264, and at block 266, a known feature is accepted for training from the user. At block 268, a training entry array is developed from the positive and negative training value sets; this is described in more detail with reference to FIGS. 8-9. At block 270, a decision is made as to whether the training entry value set exists in the raw-data datastore. If YES at block 270, the method 242 proceeds to block 272; if NO at block 270, the method 242 proceeds to block 276.

At block 272 of FIG. 7, a decision is made as to whether the known feature is associated with the training entry value set in the raw-data datastore. If YES at block 272, at block 274 the known feature count for the training entry is incremented, and the method 242 proceeds to block 280. If NO at block 272, the method 242 proceeds to block 278.

At block 276 of FIG. 7, the training entry value set is appended to the raw-data datastore. At block 278, the known feature is associated with the training entry value set in the raw-data datastore, and the method 242 proceeds to block 280.

At block 280 of FIG. 7, a decision is made as to whether there are any more training entry value sets in the training entry array. If YES at block 280, the method 242 returns to block 270; if NO at block 280, at block 282 the method 242 for training a known feature is complete.

FIG. 8 shows an example method 268/314 for developing a training entry array from positive and negative training value sets. The method 268/314 initializes at block 284, and at block 286, a training type and the positive and negative training value sets are retrieved. At block 288, the positive training value sets are assigned to the training entry array. At block 290, a decision is made as to whether the user is performing adjusted training. If YES at block 290, at block 292 all the negative training value sets are removed from the training entry array; this is described in more detail with reference to FIG. 9. The method 268/314 then proceeds to block 294. If NO at block 290, at block 294 the method 268/314 for developing a training entry array is complete.

FIG. 9 shows an example method 292 for performing adjusted training. In one embodiment, relative and/or adjusted training are available. The method 292 initializes at block 296, and at block 298, a training entry value set is selected from a set of negative training value sets. At block 300, a decision is made as to whether the training type is set to absolute adjusted training. If YES at block 300, at block 302 all value sets matching the current value set are removed from the training entry array, and the method 292 proceeds to block 306. If NO at block 300, at block 304 one value set matching the current value set is removed from the training entry array, and the method 292 proceeds to block 306.

At block 306 of FIG. 9, a decision is made as to whether there are any training entry value sets remaining in the set of negative training value sets. If YES at block 306, the method 292 returns to block 298. If NO at block 306, at block 308 the method 292 for performing adjusted training is complete.

FIG. 10 shows an example method 246 for untraining a known feature. The method 246 initializes at block 310, and at block 312, a known feature is accepted from the user for untraining. At block 314, a training entry array is developed from the positive training value sets; this is described in more detail with reference to FIGS. 8-9. At block 316, a decision is made as to whether the training entry value set exists in the raw-data datastore. If YES at block 316, the method 246 proceeds to block 318; if NO at block 316, the method 246 proceeds to block 326.

At block 318 of FIG. 10, a decision is made as to whether the known feature is associated with the training entry value set. If YES at block 318, the method 246 proceeds to block 320; if NO at block 318, the method 246 proceeds to block 326. At block 320, the known feature association is removed from the training entry value set. At block 322, a decision is made as to whether any of the known features remain associated with the training entry value set. If YES at block 322, the method 246 proceeds to block 326. If NO at block 322, at block 324 the training entry value set is removed from the raw-data datastore, and the method 246 proceeds to block 326.

At block 326 of FIG. 10, a decision is made as to whether there are any more training entry value sets in the training entry array. If YES at block 326, the method 246 returns to block 316. If NO at block 326, at block 328 the method 246 for known feature untraining is complete.

For illustrative purposes, the creation and use of a raw-data datastore as disclosed herein is exemplified with reference to the imagery example as shown in FIGS. 11-25.

FIG. 11 is an example data array representing a two-dimensional, grey-scale, 20-data element (i.e., pixel) by 20-data element image selection of two features; the first feature exists in the upper left quadrant of the FIG. 11 data array, and the second feature exists in the lower right quadrant. The X-location coordinate for each data element of the data array is indicated by the corresponding label in the column header, and the Y-location coordinate for each data element is indicated by the corresponding label in the row header. This image selection of two features, which can represent separate and discretely definable items, objects, patterns, or entities or can exist as image background or “noise,” has a total of 400 data elements. In this instance, the numbers shown within the data array are the grey-scale pixel values of the original image selection, while in an alternate instance the numbers represent some other quantifiable characteristic (e.g., data source, location reference, brightness, resolution, elevation) of the data elements. Ultimately, the data element values (or location references) depicted in the FIG. 11 data array are captured, analyzed, and stored in a raw-data datastore during data analysis using pre-selected evaluation algorithms or methods and a pre-determined TDA.

The user-specified, preset, or automatically determined TDA, which is used to capture the data values (or location references) inherent to the corresponding data elements of the FIG. 11 data array, can exist in any geometric configuration and can capture the data values (or location references) of any number of data elements in any applicable order or fashion. Several examples of TDAs, not all of which necessarily represent the preferred TDA embodiment in all data types, modalities, submodalities, etc., are presented forthwith.

In one such example, the TDA can exist as any odd-numbered, perfect square of data (e.g., a three-data element by three-data element, seven-data element by seven-data element, or any odd-number N-data element by odd-number N-data element area of data) surrounding a single, centralized TDE. FIG. 12 shows a seven-pixel by seven-pixel TDA (hereafter “7×7 TDA”) with a single, centralized TDE. In one embodiment, the data values (or location references) inherent to the corresponding data elements of the original data set of FIG. 11 are captured in any applicable order or fashion using the 7×7 TDA and subsequently function to populate the raw-data datastore. In one embodiment and following raw-data datastore training and subsequent data analysis and feature recognition exercises, such as use of the previously trained raw-data datastore as the source data for generation of an associated algorithm datastore, the 7×7 TDA of FIG. 12 can be altered, changed, modified, or reconfigured to become any subset or portion thereof such as the eight-radial, three-data elements-per-radial, TDA (hereafter “8×3 TDA”) as shown in FIG. 13, the adjacent-data element TDA as shown in FIG. 14, or the adjacent cardinal-data element TDA as shown in FIG. 15.

In another such example, the TDA can exist as any even-numbered, perfect square of data (e.g., a four-data element by four-data element, eight-data element by eight-data element, or any even-number N-data element by even-number N-data element area of data) absent a single, centralized TDE but instead surrounding a centralized TDE comprised of pluralities of data elements. FIG. 16 shows an eight-data element by eight-data element TDA (hereafter “8×8 TDA”) with a TDE comprised of a localized grouping of four central data elements. In one embodiment, the data values (or location references) inherent to the corresponding data elements of the original data set of FIG. 11, are captured in any applicable order or fashion using the 8×8 TDA and subsequently function to populate the raw-data datastore. In one embodiment and following raw-data datastore training and subsequent data analysis and feature recognition exercises, the 8×8 TDA of FIG. 16 can be altered, changed, modified, or reconfigured to become any subset or portion thereof, such as a series of concentric squares surrounding a grouping of centralized data elements functioning as the TDE as shown in FIG. 17.

For this example, the 8×3 TDA of FIG. 13, which exists as a localized grouping of 24 data elements arranged in a starburst-like pattern around a single, centralized TDE (hereafter “TDA1”), is selected for use in the generation of a raw-data datastore. As shown in FIG. 11, the first and last three rows and columns of data element values are highlighted because the data elements contained therein do not abut the requisite adjacent data elements as required for complete analysis in accordance with TDA1; as such, these data elements are not considered “valid” during processing. Use of TDA1, which represents the preferred TDA embodiment in this case but not necessarily the preferred TDA embodiment in all data types, modalities, submodalities, etc., ensures that at some point during generation of the subsequent data value cache and ultimately the raw-data datastore, the data value of every data element in the original data set selection is considered. Once the raw-data datastore is populated with the data values as stored in the data value cache, the user is able to generate algorithm datastores using varying pluralities of evaluation algorithms and/or subsets or portions of the original TDA1 so as to evaluate the performance and efficacy of each.

For this example, the 8×3 TDA of FIG. 13, which exists as a localized

In this example, a series of 25 consecutively executed “GetValue” routines (i.e., methods, processes, algorithms) (hereafter “Value1” through “Value25”), each corresponding to a particular member-data element of TDA1 for a given TDE and each returning a single member-data element value, are used to capture the data values of the original data set of FIG. 11. FIG. 18 shows TDA1 with each member-data element labeled with the relevant “GetValue” routine that is to evaluate it. The member-data elements of TDA1 are respectively evaluated by any of the 24 serially executed “GetValue” routines, assuming each “GetValue” routine assesses only one member-data element of TDA1. Also, the “GetValue” routine that evaluates a particular member-data element of TDA1 for a given TDE must operate on the same positional member-data element of all subsequent TDA1s.

Referencing the flowchart of FIG. 6, data value capture of the original data set of FIG. 11 begins with generation of a data value cache, which is initialized as an organizational storage structure used to amass the data value capture results from each TDA for each valid TDE; the data value cache is indexed by TDE location for reference purposes only. Alternatively, the data value cache stores only selections of the original data set.

In one embodiment, data capture of the original data of FIG. 11 begins at any valid, user-specified, preset, or automatically determined data element. In one instance, processing with the first “GetValue” routine (i.e., Value1) using TDA1 initializes at TDE (4, 4) and returns a value of 159. In one embodiment, the resultant value 159 is stored in the data value cache at the corresponding TDE location (i.e., TDE location (4, 4)). In an alternate embodiment, the resultant value 159 is stored in any user-specified, preset, or automatically determined storage structure or temporary storage device that is sized and addressed in the same manner as the original data set.

In one instance, the data values of the remaining member-data elements of TDA1 for TDE (4, 4) are then captured with the other 24 serially ordered and executed “GetValue” routines (i.e., Value2 through Value 24) in accordance with the schematic of FIG. 18.

Following the data capture method of the member-data elements of TDA1 for TDE (4, 4), capture proceeds to the next valid TDE (i.e., data element (5, 4)) and then continues until the collection of valid TDEs in the original data set of FIG. 11 is exhausted. In an alternate embodiment, data capture moves to any unprocessed, valid TDE in the original data set.

FIGS. 19A-19G show an example data table for one embodiment of the complete data value cache, which is initialized as an organizational structure to store the captured data values resulting from processing each valid TDE of the original data set of FIG. 11 with the series of consecutively ordered GetValue methods using TDA1; the data value cache is indexed by TDE location for reference purposes only.

Once population of the data value cache is complete, the cache is returned to the raw-data datastore processing engine. Referencing FIG. 5, one or pluralities of selections, or regions of interest, as sourced from the original data set of FIG. 11 and that are to be trained (or untrained) into the raw-data datastore as a particular known feature(s), are defined by the user. In this example, a region of interest, which is synonymous with selection of the entire upper left quadrant (i.e., data element locations in the rectangular area with corners at (1, 1) through (10, 10)) of the original data set, is selected for training into the raw-data datastore as known feature 1 (hereafter “KF1”). Accordingly, the positive training value sets, which are those data value sets existing within the selection for KF1, are retrieved from the data value cache of FIGS. 19A-19G. If the user has selected adjusted training, the negative training value sets, which are those data value sets that do not exist within the selection for KF1, are retrieved from the data value cache as well. For this example, assume the user is not performing adjusted training. In accordance with FIG. 7, which describes the process for training a given known feature into a raw-data datastore, an intermediary training entry array, which functions to append the raw-data datastore with the value sets associated with KF1 as stored in the data value cache, is developed from the applicable positive training value sets. Also in this example, the user trains a second region of interest, which is synonymous with selection of the entire lower right quadrant (i.e., data element locations in the rectangular area with corners at (11, 11) through (20, 20) of the original data set of FIG. 11, into the raw-data datastore as known feature 2 (hereafter “KF2”).

FIGS. 20A-20D show an example data table representing one embodiment of the complete raw-data datastore. For illustrative purposes, FIGS. 20A-20D also show an additional reference column, which is labeled “TDE Loc Ref,” listing an index of the TDE locations from which the raw-data datastore entries are sourced. Preferably, the raw-data datastore does not store these TDE location references and indeed doing so is ambiguous without retaining the data source information in any application where multiple data sources, or data set selections, are used to create a raw-data datastore. The TDE location references are provided in FIGS. 20A-20D simply for clarity with regard to the later examples and are useful for illustrating a single traversal of the raw-data datastore during creation of subsequent algorithm datastores. Moreover, the TDE location reference indices are included in the resulting algorithm datastores so that the examples can be followed from the original data set through to the final results. Any traversal method that processes each raw-data datastore entry exactly once will yield the correct results. In alternate embodiments, the raw-data datastore can exist in any format, such as a synaptic web as disclosed by Brinson, et al, in U.S. patent application 2007/0244844.

Continuing the same example, an algorithm datastore is trained using the previously created and populated raw-data datastore (shown in FIGS. 20A-20D) as the source data instead of having to be manually trained using the original data set of FIG. 11. The creation and population of an algorithm datastore proceeds in a manner such as disclosed by Brinson, et al., in U.S. patent application 2007/0244844, while in an alternate embodiment algorithm datastore generation and population is accomplished using any methodology, application, or engine intended for use in the same or a similar manner. Likewise, any applicable storage device, such as a data array, database, alternative datastore, etc., can be used in place of the algorithm datastore for the purpose of storing the data processing results. For illustrative purposes, training of subsequent algorithm datastores from the previously generated raw-data datastore is discussed succinctly forthwith.

In this example, TDA1 (as shown in FIG. 13) and the TDA evaluation algorithms “Sum of Radial Distribution” (hereafter “ALG1”) and “Sum of First Non-zero Deviation” (hereafter “ALG2”) are selected for use in training and populating an algorithm datastore (hereafter “AlgDS1”) with the data values and patterns inherent to the raw-data datastore entries.

As described herein, ALG1 is calculated as a predefined value for each radial of TDA1. The “radial distribution” is dependent upon whether the data element values of a given radial are different from the TDE value; if so, the distance between the first-different data element value and the TDE value is determined. In one embodiment, radial distribution values of 16, 8, and 4 are used, while in an alternate embodiment any user-specified, preset, or automatically determined radial distribution values are used. For a given TDA radial: if the data element nearest in location to the TDE has a value different than the TDE value, then the radial distribution for that radial is assigned a value of 16; if the data element nearest in location to the TDE has the same value but the data element second-nearest in location to the TDE has a value different than the TDE value, then the radial distribution for that radial is assigned a value of 8; if the data elements nearest and second-nearest in location to the TDE have the same value but the data element third-nearest in location to the TDE has a value different than the TDE value, then the radial distribution for that radial is assigned a value of 4; otherwise, the radial distribution is assigned a value of 0. With reference to TDA1, since the maximum radial distribution value for each radial is 16 and there are eight total radials, the resultant value range of ALG1 is 0 to 128. A higher resultant sum suggests a higher data element value variance closer to the TDE, while a lower resultant sum indicates more data element homogeneity surrounding the TDE.

As described herein, ALG2 is calculated for each radial of TDA1. The “first non-zero deviation” of a given TDA radial is surmised through the identification of the data element first-nearest in location to the TDE with a value that is different from the value of the TDE; the absolute difference between this data element value and the TDE value is then calculated. With reference to TDA1, since the maximum first non-zero deviation value for each radial is 255 and there are eight total radials, the resultant value range of ALG2 is 0 to 2,040. A higher resultant sum suggests greater difference between the data element values, taken as a whole and comprising the TDA, and the TDE value.

Training of AlgDS1 begins at any user-specified, preset, or automatically determined entry in the raw-data datastore. For this example, training initializes at the raw-data datastore entry corresponding with TDE location reference (4, 4) as shown in FIG. 20A and returns a value of 128, count 1, per the following calculations. Referencing the TDA1 schematic of FIG. 13, the radial distribution of Radial 1 is assigned a value of 16 as the data element (i.e., data element (5, 4)) nearest in location to the TDE has a different value (i.e., data element value 164 versus TDE value 159). For Radial 2, the radial distribution is assigned a value of 16 as the data element (i.e., data element (5, 5)) nearest in location to the TDE has a different value (i.e., data element value 155 versus TDE value 159). Processing continues until each radial of TDA1 for TDE location reference (4, 4) is algorithmically evaluated and temporarily stored. The complete calculations corresponding to algorithmic evaluation of TDE location reference (4, 4 ) with ALG1 using TDA1 are shown in FIG. 21. The resultant radial distribution values (i.e., 16, 16, 16, 16, 16, 16, 16, 16) for each of the eight radials of TDA1 for TDE location reference (4, 4) are then summed to yield a resultant data value of 128, and this resultant summation is stored in AlgDS1.

In one instance, the raw-data datastore entry corresponding to TDE reference location (4, 4) is then evaluated with ALG2 using TDA1. Referencing the TDA1 schematic of FIG. 13, the first non-zero deviation of Radial 1 is assigned an absolute difference value of 5 as the data element (i.e., data element (5, 4)) nearest in location to the TDE (i.e., location reference (4, 4)) has a different value (i.e., data element value 164 versus TDE value 159). For Radial 2, the first non-zero deviation is assigned an absolute difference value of 4 as the data element (i.e., data element (5, 5)) nearest in location to the TDE has a different value (i.e., data element value 155 versus TDE value 159). Processing continues until each radial of TDA1 for TDE location reference (4, 4) is algorithmically evaluated and temporarily stored. The complete calculations corresponding to algorithmic evaluation of TDE location reference (4, 4) with ALG2 using TDA1 are shown in FIG. 22. The resultant first-non-zero-deviation values (i.e., 5, 4, 17, 47, 15, 8, 14, 14) for each of the eight radials of TDA1 for TDE location reference (4, 4) are then summed to yield a resultant value of 124, and this final summation is stored in AlgDS1.

Following the processing of the raw-data datastore entry corresponding to TDE location reference (4, 4) with ALG1 and ALG2 using TDA1, training of A1gDS1 steps to the next raw-data datastore entry of FIGS. 20A-20D and then continues until the collection of raw-data datastore entries is exhausted. In an alternate embodiment, all valid raw-data datastore entries are processed with a single evaluation algorithm using TDA1 prior to initialization of processing with any subsequent evaluation algorithms.

FIG. 23 shows an example data table for one embodiment of the complete AlgDS1, which is initialized as an organizational structure to store the algorithm values resulting from processing each raw-data datastore entry with ALG1 and ALG2 using TDA1; AlgDS1 is indexed by TDE location for reference purposes only.

As a second aspect of this example, the adjacent-data element TDA of FIG. 14 (hereafter “TDA2”), which is a derivative of TDA1 and exists as a localized grouping of eight adjacent data elements surrounding a single, centralized TDE, and the evaluation algorithms “Mean Value” (hereafter “ALG3”), as defined by EQUATION 1, and “Low Value Spread” (hereafter “ALG4”), as defined by EQUATION 2, are selected for use in training and populating another algorithm datastore (hereafter “AlgDS2”) with the data values and patterns inherent to the raw-data datastore entries.

$\begin{matrix} {\overset{\_}{x} = \frac{\sum\limits_{i = 1}^{n}x_{i}}{n}} & {{EQUATION}\mspace{14mu} 1} \end{matrix}$

-   -   Where x is the mean value,         -   x_(i) is the data element value at each TDE location,         -   and n is the data set sample size (i.e., the number of             member data-elements that are to be evaluated in the TDA for             a given TDE).             S=x _(i) _(max) −x _(i) _(min) ; if S>16, return 0; if S≦16,             return S  EQUATION 2     -   Where S is the value spread,     -   x_(i) _(max) is the maximum data element value of the TDA,     -   and x_(i) _(min) the minimum data element value of the TDA.         -   and x_(i) _(min) is the minimum data element value of the             TDA.

In one embodiment, training of AlgDS2 begins at any user-specified, preset, or automatically determined, entry in the raw-data datastore. In one instance, training with ALG3 using TDA2 initializes at the raw-data datastore entry corresponding to TDE location reference (4, 4) (as shown in FIG. 20A) and returns a value of 167, count 1, per the following calculations.

-   -   1. Sum the member-data element values of TDA2 for the raw-data         datastore entry corresponding to TDE location reference (4, 4);         in this instance, exclude the TDE value from the calculations.

${\sum\limits_{i = 1}^{n}x_{i}} = \left( {164 + 155 + 176 + 206 + 174 + 167 + 145 + 145} \right)$ ${\sum\limits_{i = 1}^{n}x_{i}} = \left( {1\text{,}332} \right)$

-   -   2. Divide the sum from Step 1 by the total number of member-data         elements of TDA2 for TDE location reference (4, 4); exclude the         TDE from the count.

$\overset{\_}{x} = \frac{1\text{,}332}{8}$ $\overset{\_}{x} = 166.5$

-   -   3. Round the result of Step 2 to the nearest whole number.         x≅167         In one embodiment, the resultant value 167 is stored in AlgDS2.

In one instance, the raw-data datastore entry corresponding to TDE location reference (4, 4) is then processed with ALG4 using TDA2; a resultant value of 0, count 1, is returned per the following calculations.

-   -   1. Determine the member-data element of TDA2 for TDE location         reference (4, 4) with the highest value; in this instance,         exclude the TDE value from the calculations.         TDA2 member-data element values: 164, 155, 176, 206, 174, 167,         145, 145         x_(i) _(max) =206     -   2. Determine the member-data element of TDA2 for TDE location         reference (4, 4) with the lowest value; exclude the TDE value         from the calculations.         x_(i) _(min) =145         Calculate the spread of values by subtracting the member-data         element with the lowest value, as determined in Step 2, from the         member-data element with the highest value, as determined in         Step 1.         S=x _(i) _(max) −x _(i) _(min)         S=206−145         S=61     -   4. Determine if the spread of values, which is calculated in         Step 3, is greater than 16. If YES, return 0; if NO, return the         spread of values as calculated in Step 3.         61>16         Return 0.         In one embodiment, the resultant value 0 is stored in AlgDS2.

Following the processing of the raw-data datastore entry corresponding to TDE location reference (4, 4) with ALG3 and ALG4 using TDA2, processing steps to the next raw-data datastore entry, which in one instance corresponds to TDE location reference (5, 4), and then continues until the collection of raw-data datastore entries is exhausted. In an alternate embodiment, all raw-data datastore entries are processed with a single evaluation algorithm using TDA2 prior to initialization of processing with any subsequent evaluation algorithms.

FIG. 24 shows an example data table for one embodiment of the complete AlgDS2, which is initialized as an organizational structure to store the algorithm values resulting from processing each raw-data datastore entry with ALG3 and ALG4 using TDA2; AlgDS2 is indexed by TDE location for reference purposes only.

As a third aspect of this example, the adjacent cardinal-data elements TDA of FIG. 15 (hereafter “TDA3”), which is a derivative of TDA1 and exists as a localized grouping of four cardinally-positioned data elements surrounding a single, centralized TDE, and the evaluation algorithms “Absolute Deviation” (hereafter “ALG5”), as defined by EQUATION 3, “Spread of Deviations” (hereafter “ALG6”), as defined by EQUATION 4, and ALG3, as previously defined by EQUATION 1, are selected for use in training and populating another algorithm datastore (hereafter “AlgDS3”) with the data values and patterns inherent to the raw-data datastore entries.

$\begin{matrix} {|D| = \frac{\sum\limits_{i = 1}^{n}\left| {x_{i} - \overset{\_}{x}} \right|}{n}} & {{EQUATION}\mspace{14mu} 3} \end{matrix}$

-   -   Where |D| is the mean absolute deviation,         -   x_(i) is the member-data element value,         -   x is the mean value,         -   and n is the data set sample size (i.e., the number of             member-data elements that are to be evaluated in the TDA for             a given TDE).             S=(x _(i) −x _(TDE))_(max)−(x _(i) −x             _(TDE))_(min)  EQUATION 4     -   Where S is the spread of deviations,         -   x_(i) is the member-data element value,         -   and x_(TDE) is the TDE value.

In one embodiment, training of AlgDS3 begins at any user-specified, preset, or automatically determined entry in the raw-data datastore. In one instance, training with ALG5 using TDA3 initializes at the raw-data datastore entry corresponding to TDE location reference (4, 4) as shown in FIG. 20A and returns a value of 10, count 1, per the following calculations.

-   -   1. Calculate the mean value of the member-data element values of         TDA3 for the raw-data datastore entry corresponding to TDE         location reference (4, 4); in this instance, exclude the TDE         value from the calculations.

$\overset{=}{x} = \frac{164 + 176 + 174 + 145}{4}$ $\overset{=}{x} = \frac{649}{4}$ $\overset{=}{x} = 164.75$ $\overset{=}{x} \cong 165$

-   -   2. Sum the absolute differences between each member-data element         value in TDA3 for TDE location reference (4, 4) and the mean         value, as derived in Step 1; exclude the TDE value.

${\sum\limits_{i = 1}^{n}\left| {x_{i} - \overset{\_\_}{x}} \right|} = \left( \left| {164 - 165} \middle| {+ \left| {176 - 165} \middle| {+ \left| {174 - 165} \middle| {+ \left| {145 - 165} \right|} \right.} \right.} \right. \right)$ ${\sum\limits_{i = 1}^{n}\left| {x_{i} - \overset{\_}{x}} \right|} = \left( \left| {- 1} \middle| {+ \left| 11 \middle| {+ \left| 9 \middle| {+ \left| {- 20} \right|} \right.} \right.} \right. \right)$ ${\sum\limits_{i = 1}^{n}\left| {x_{i} - \overset{\_}{x}} \right|} = \left( {1 + 11 + 9 + 20} \right)$ ${\sum\limits_{i = 1}^{n}\left| {x_{i} - \overset{\_}{x}} \right|} = (41)$

-   -   3. Divide the sum from derived Step 2 by the total number of         member-data elements of TDA3 for TDE location reference (4, 4);         exclude the TDE from the count.

$|D| = {\left. \frac{41}{4} \middle| D \right| = \left. 10.25 \middle| D \middle| {\cong 10} \right.}$ In one embodiment, the resultant value 10 is stored in AlgDS3.

In one instance, the raw-data datastore entry corresponding to TDE location reference (4, 4) is then processed with ALG6 using TDA3; a resultant value of 31, count 1, is returned per the following calculations.

-   -   1. Determine the member-data element of TDE3 for TDE location         reference (4, 4) with the highest deviation value from the TDE         location reference (4, 4) data value of 159.         D_((4,4))=159         D_((5,4))=164         D _((5,4)) −D _((4,4))=164−159=5         D_((4,5))=176         D _((4,5)) −D _((4,4))=176−159=17         D_((3,4))=174         D _((3,4)) −D _((4,4))=174−159=15         D_((4,8))=145         D _((4,8)) −D _((4,4))=145−159=−14         D _(max)=(x _(i) −x _(TDE))_(max)=17     -   2. Determine the member-data element of TDE3 for TDE location         reference (4, 4) with the lowest deviation value from the TDE         location reference (4, 4) data value of 159.         D _((5,4)) −D _((4,4))=164−159=5         D _((4,5)) −D _((4,4))=176−159=17         D _((3,4)) −D _((4,4))=174−159=15         D _((4,8)) −D _((4,4))=145−159=−14         D _(min)=(x _(i) −x _(TDE))_(min)=−14     -   3. Calculate the difference, or spread of values, between         D_(max) and D_(min), which are respectively derived in Steps 1         and 2.         S=D _(max) −D _(min)         S=17−(−14)         S=31         In one embodiment, the resultant value 31 is stored in AlgDS3.

In one instance, the raw-data datastore entry corresponding to TDE location reference (4, 4) is then evaluated with ALG3 using TDA31 a resultant value of 165, count 1, is returned per the following calculations.

-   -   1. Sum the member-data element values of TDA3 for the raw-data         datastore entry corresponding to TDE location reference (4, 4);         in this instance, exclude the TDE value from the calculations.

${\sum\limits_{i = 1}^{n}x_{i}} = \left( {164 + 176 + 174 + 145} \right)$ ${\sum\limits_{i = 1}^{n}x_{i}} = (659)$

-   -   2. Divide the sum from Step 1 by the total number of member-data         elements of TDA3 for TDE location reference (4, 4); exclude the         TDE from the count.

$\overset{\_}{x} = \frac{659}{4}$ $\overset{\_}{x} = 164.75$

-   -   3. Round the result of Step 2 to the nearest whole number.         x≅165         In one embodiment, the resultant value 165 is stored in AlgDS3.

Following the processing of the raw-data datastore entry corresponding to TDE location reference (4, 4) with ALG5, ALG6, and ALG3 using TDA3, training of AlgDS3 steps to the next raw-data datastore entry and then continues until the collection of raw-data datastore entries is exhausted. In an alternate embodiment, all valid raw data-datastore entries are processed with a single evaluation algorithm using TDA3 prior to initialization of processing with any subsequent evaluation algorithms.

FIGS. 25A-25B show an example data table for one embodiment of the complete AlgDS3, which is initialized as an organizational structure to store the algorithm values resulting from processing each raw-data datastore entry with ALG5, ALG6, and ALG3 using TDA3; AlgDS3 is indexed by TDE location for reference purposes only.

In pluralities of alternate embodiments, any applicable TDA, which exists as a subset or portion of the original TDA (i.e., TDA1) used to capture data values to be stored in the raw-data datastore, and any pluralities of applicable evaluation algorithms are used to train the algorithm datastore(s).

Use of a Raw-Data Datastore in the Resolution of “Confusion”

The ideal candidate solution (i.e., evaluation algorithm set) for resolution of a given data analysis and feature recognition problem is one that uses a minimum number of evaluation algorithms to most thoroughly and aptly distinguish features. However, occasionally during data analysis exercises, the evaluation algorithms used to identify and discriminate features fail to differentiate two data elements; this failure is termed “confusion,” and it can manifest itself in two common ways. First, the original data values and patterns within selections of a data set can be exceedingly ambiguous to the point of being identical thereby preventing differentiation between two (or more) data elements; this is commonly termed “data confusion.” Second, the evaluation algorithms used during algorithm datastore training, for example, can fail to differentiate between the distinct data values and patterns of two (or more) features that the user knows to be different; this is commonly termed “algorithm confusion.” Additionally, an inherent complication to the occurrence of confusion is that in most cases, the user is unable to determine whether the original data set or selection therein and/or the data processing method, using a specifically selected combination of evaluation algorithms, are to blame for the failure.

In one case of data confusion, inadequate sensor sensitivity and/or poor data resolution can be the culprits, while in an alternate case, data confusion results from the user inadvertently and/or unknowingly including a single (or pluralities of) data element(s) in two (or more) different data set selections; subsequently, a single, discrete data element is trained into a datastore as two (or more) different known features. This latter possibility is illustrated with the simplistic data arrays of FIGS. 26A and 26B, which each represent an adjacent-data element TDA associated with a particular TDE (located at data element locations (2, 2) and (22, 22), respectively). Examination of the data values and patterns of the original data sets of FIGS. 26A and 26B confirms that data analysis results, obtained using any series of evaluation algorithms, should be the same for both data sets. However, the data set of FIG. 26A is recorded as an identification of KF1, while the data set of FIG. 26B is recorded as an identification of KF2. This is a classic example of data confusion wherein the data values and patterns inherent to the original data set selections are identical for two or more different features.

In the case of algorithm confusion, the evaluation algorithms selected for feature training into a datastore fail to distinguish between the unique data values and patterns inherent to two (or more) known features (e.g., KF3 and KF4) that are known by the user to be different. This possibility is illustrated with the simplistic data arrays of FIGS. 27A and 27B, which each represent an adjacent-data element TDA associated with a particular TDE (located at data element locations (5, 5) and (25, 25), respectively).

The data sets of FIGS. 27A and 27B are evaluated using the “Mean Value” algorithm, as previously shown in EQUATION 1, and the “Median” algorithm, as shown in EQUATION 6.

-   -   EQUATION 6: For an odd number of values in a given data set, the         median ({tilde over (x)}) is the middle value in the set. For an         even number of values, the median is computed as the arithmetic         mean of the middle two values.

The arithmetic mean value of the member-data element values of the TDA for TDE (5, 5) of FIG. 27A is 3 per the following calculations.

-   -   1. Sum the member-data element values of the TDA for TDE (5, 5);         in this instance, exclude the TDE value from the calculations.

${\sum\limits_{i = 1}^{n}x_{i}} = \left( {4 + 2 + 5 + 3 + 3 + 4 + 2 + 1} \right)$ ${\sum\limits_{i = 1}^{n}x_{i}} = (24)$

-   -   2. Divide the sum from Step 1 by the total number of member-data         elements of the TDA for TDE (5, 5); exclude the TDE from the         count.

$\overset{\_}{x} = \frac{24}{8}$ $\overset{\_}{x} = 3$

The median value of the member-data element values of the TDA for TDE (5, 5) of FIG. 27A is 3 per the following calculations.

-   -   1. List the member-data element values of the TDA for TDE (5,         5); in this instance, exclude the TDE value.         -   {4,2,5,3,3,4,2, 1}     -   2. Since there is an even number of data element values,         calculate the arithmetic mean value of the middle two data         element values; this is the median value.

$\overset{\_}{x} = \frac{\left( {3 + 3} \right)}{2}$ $\overset{\_}{x} = 3$ $\overset{\_}{x} = 3$

Similarly, the arithmetic mean value of the member-data elements of the TDA for TDE (25, 25) of FIG. 27B is 3 per the following calculations.

${1.\mspace{14mu}{\sum\limits_{i = 1}^{n}x_{i}}} = \left( {3 + 3 + 3 + 3 + 3 + 3 + 3 + 3} \right)$ $\mspace{25mu}{{\sum\limits_{i = 1}^{n}x_{i}} = (24)}$ ${2.\mspace{14mu}\overset{\_}{x}} = \frac{24}{8}$ $\mspace{31mu}{\overset{\_}{x} = 3}$

Also, the median value of the member-data elements of the TDA for TDE (25, 25) of FIG. 27B is 3 per the following calculations.

1.  {3, 3, 3, 3, 3, 3, 3, 3} ${2.\mspace{14mu}\overset{\_}{x}} = \frac{\left( {3 + 3} \right)}{2}$ $\mspace{31mu}{\overset{\_}{x} = 3}$ $\mspace{31mu}{\overset{\_}{x} = 3}$

Upon comparison of the algorithmically ascertained results for the different data sets of FIGS. 27A and 27B, it is obvious that the mean value and median value algorithms fail to distinguish the uniqueness of the data values and patterns inherent to the different data sets; here, identical algorithm results are attained from evaluation of different data value sets, which ultimately represent different known features.

The resolution of data and/or algorithm confusion, both of which are described in detail above, is simplified and benefits from the use of a raw-data datastore. With regard to a typical algorithm datastore, it can be difficult for a user to specifically identify the problematic data element location(s) because there is no system functionality allowing such delineation. Ineffectual training events, which can manifest as false-positive feature identifications, for example, may ultimately result in the user opting to retrain the entire data set into the algorithm datastore using different data set selections, evaluation algorithms, and/or TDAs; this is a time consuming and tedious process. In contrast, if data analysis of a given data set(s) begins with the training of a raw-data datastore using an information-capturing algorithm (e.g., “GetValue” or “GetLocation”), for example, the identification of confusion is a straightforward endeavor accomplished via the selection of one or pluralities of additional or substitute evaluation algorithms that result in differentiation between the data sets.

In one case, data confusion can arise when a single data element(s) is included in two (or more) different data set selections and is therefore trained as two (or more) different known features. The following is an example of data confusion resolution using a raw-data datastore.

FIG. 28 shows an example of a truncated selection of entries from a raw-data datastore; here, each of the TDE reference locations are sourced from Data Set 1 and are evaluated using a series of 25, consecutively ordered “GetValue” routines and TDA1. In this example, TDE location references “V,” “W,” “X,” “Y,” and “Z” are trained into the raw-data datastore as KF5, while TDE location references “Z,” “A,” “B,” “C,” and “D,” are trained as KF6. Note the two raw-data datastore entries associated with TDE location reference “Z” are highlighted because these are associated with the same raw-data datastore entries thus suggesting an instance of data confusion possibly resulting from the user inadvertently and unknowingly training the same TDE location reference, “Z,” as two different known features (i.e., KF5 and KF6).

In another case, data confusion can result when a given data element is not unique within the data set source. This can occur when the same patterns of data elements exist in two different locations within the data set source. In yet another case, data confusion can result from the capture of low-resolution data and/or inadequate sensor sensitivity.

In one embodiment, the user can be notified as to the occurrence of data confusion within a particular training exercise via a mechanism akin to “hit count.” In one embodiment, the system notifies the user of the presence of data confusion by displaying an actual count of the incidences or a percentage of occurrences relative to the presence of positive feature identifications. In an alternate embodiment, any user-specified, preset, automatically determined, and/or industry- or system-acceptable methodology or mechanism intended for use in the same or a similar manner can be employed for data confusion notification; this can include a system alarm, a visual representation that paints the confused data element(s) a pre-selected color, etc. Further, following identification of data confusion, the original feature training entries, as stored in the raw-data datastore, can be improved via any suitable method including, inter alia, sequence untraining and retraining with improved data selection(s), use of modified TDAs, and/or direct editing of the raw-data datastore's training entries so as to remove or correct erroneous entries.

In another example of confusion, algorithm confusion exists when the algorithm processing results for different data sets yields the same algorithm value sets for feature identification. The following example of algorithm confusion resolution assumes prior training of a raw-data datastore with the original data values and patterns inherent to the source data set(s).

FIG. 29 shows a truncated selection of entries from a raw-data datastore. TDE location references “Q,” “R,” “S,” “T,” and “U,” as sourced from Data Set 2, are evaluated using a user-specified selection of evaluation algorithms (i.e., “ALGA,” “ALGB,” “ALGC,” “ALGD,” and “ALGE”) and TDA1; the resultant data values and patterns are subsequently trained into the algorithm datastore as KF7. Moreover, TDE location references “E,” “F,” “G,” “H,” and “I,” as sourced from Data Set 3, are evaluated using the same series of evaluation algorithms and TDA1; the resultant data values and patterns are trained into the same algorithm datastore as KF8. Note the two algorithm datastore entries associated with TDE location references “U” and “E” are highlighted because these different data elements, sourced from different data sets (i.e., different selections of data values as stored in a raw-data datastore) but trained into the same algorithm datastore, are associated with the same data values but are trained as two different known features (i.e., KF7 and KF8) thus suggesting an instance of algorithm confusion wherein the selected evaluation algorithms are incapable of differentiating the data elements.

In one embodiment, the use of a raw-data datastore benefits resolution of algorithm confusion in that the raw-data datastore is able to provide a listing of each set of data values and patterns (i.e., each raw-data datastore entry) for which a given candidate-solution of evaluation algorithms is inadequate thereby making the task of modifying or adding evaluation algorithms to the existing candidate-solution, where the objective is to improve the ability to discriminate to an arbitrary degree, relatively simple. As previously explained, this is because the premise behind a raw-data datastore is the allowance for an evaluation algorithm “plug-and-play” capability wherein different evaluation algorithms and combinations thereof can be used to evaluate a given data set selection(s) once the original data values and patterns of the raw data set(s) are trained into an associated raw-data datastore.

FIG. 30 shows an example of a three-dimensional data set as it is trained into a raw-data datastore. The data sources, as well as the actual locations for each training entry in the system, are preserved in this version; as such, the actual data value sets are accessible from the source data sets. In this example, note that data confusion, resulting from overlapping training, is immediately apparent at the position where KF10 and KF11 are trained at the same data point. This can be compared to the full listing of data confused training entries to provide the user with additional separation by cause. In one embodiment, an automated display of the actual data source location(s) of any training entry can be generated for user reference thereby facilitating the resolution of data confusion issues. Moreover, the system allows automated retraining of a new datastore using any compatible sample data area available.

FIG. 31 shows one embodiment of the present invention wherein both the original selections and data sets are retained as part of the raw-data datastore. The training entries reference the data sources and their locations within the data sources thereby allowing training locations to be displayed to the user for any entry in situations where locations within selections are retained. Note that data confusion is indicated where “Data Values 3” is trained as both KF13 and KF14 in separate data selections. Again, if the locations are retained, all information is present and the same capabilities exist as are presented in FIG. 30.

In an alternate embodiment, the raw-data datastore training entries do not retain the selection locations; in such a case, less exact information about the location of each training entry is displayed, but at least the possible locations within the actual selections are available. An embodiment that saves only the data values for the selections and discards the original data source(s) also allows for most of these capabilities but fails in the provisions to automatically retrain using non-subset TDAs and to identify the exact cause of any data confusion, such as selection overlay or ambiguous data, that is present.

While the preferred embodiment of the present invention has been illustrated and described, as noted above, many changes can be made without departing from the spirit and scope of the invention. Accordingly, the scope of the invention is not limited by the disclosure of the preferred embodiment. Instead, the invention should be determined entirely by reference to the claims that follow. 

The embodiments of the invention, in which exclusive property or privilege is claimed, are defined as follows:
 1. A system for creation and use of a raw data datastore, comprising: a computer having a processor and a memory, the memory containing a database of raw data, the memory further containing stored programming instructions operable by the processor to: create the raw data datastore and store the raw data datastore in memory, the raw data datastore containing references to the database of raw data that are associated with known features within the database of raw data and defects associated with the database of raw data; wherein the defects associated with the database of raw data comprise one or more instances of data confusion present in the database of raw data; and further wherein the one or more instances of data confusion comprise a plurality of locations within the database of raw data in which different data elements produce the same results upon operation by a common algorithm, and further wherein such instances of data confusion are identified within the database of raw data and are stored within the raw data datastore.
 2. The system of claim 1, further comprising a display associated with the computer, and wherein the stored programming instructions further enable the processor to present on the display a representation of the instances of data confusion.
 3. The system of claim 2, wherein the representation of the instances of data confusion comprises an indication of the actual count of the instances of data confusion.
 4. The system of claim 1, wherein the stored programming instructions further enable the processor to modify a trained association between one or more known features and the data elements within the raw data database that are associated with instances of data confusion.
 5. The system of claim 4, wherein the modification of the trained association further comprises one or both of modifying a target data area related to the data elements or eliminating the data element as being associated with the known feature.
 6. The system of claim 1, wherein the defects associated with the database of raw data further comprise one or more instances of algorithm confusion present in the database of raw data.
 7. The system of claim 6 wherein the one or more instances of algorithm confusion comprise a plurality of target data areas that are substantially indistinguishable from one another upon operation by plurality of different algorithms.
 8. The system of claim 7, further comprising a display associated with the computer, and wherein the stored programming instructions further enable the processor to present on the display a representation of the instances of algorithm confusion.
 9. The system of claim 8, wherein the representation of the instances of algorithm confusion comprises an indication of the actual count of the instances of algorithm confusion.
 10. The system of claim 9, wherein the stored programming instructions further enable the processor to modify a trained association between one or more known features and the data areas within the raw data database that are associated with instances of algorithm confusion.
 11. The system of claim 10, wherein the modification of the trained association further comprises one or both of modifying the target data area related to the instance of algorithm confusion or eliminating the data area as being associated with the known feature.
 12. The system of claim 1, wherein the references to the database of raw data comprise pointers to locations within the database of raw data.
 13. The system of claim 1, wherein the references to the database of raw data comprise a subset of values from the database of raw data.
 14. The system of claim 1, wherein the raw data datastore is created by training the database of raw data using one or more algorithms operating on a plurality of target data areas within the database of raw data.
 15. The system of claim 1, wherein the raw data datastore further comprises an association between one or more algorithms and a plurality of specified portions of the database of raw data upon which the one or more algorithms are operated in order to produce the associations between the database of raw data and at least one of the known features or the defects.
 16. The system of claim 15, wherein the stored programming instructions further cause the processor to modify the association of known features by processing an additional algorithm on at least one of the target data areas indicated within the raw data datastore to be associated with the known feature.
 17. The system of claim 16, wherein the stored programming instructions further cause the processor to update the raw data datastore with at least one additional association between the additional algorithm and the known feature. 